// ================================
// 算法特化的基本概念
// ================================
"算法特化"（Algorithm Specialization）是一种重要的模板编程技术，它允许我们为特定类型提供高度优化的算法实现，同时保持通用接口。《C++ Templates》第20章的20.1节详细介绍了这一技术。

算法特化的核心思想是：虽然通用算法可以处理各种类型，但对于特定类型，我们可能有更高效的专用实现。通过模板特化和重载，我们可以让编译器自动选择最适合的实现。

// ================================
// 算法特化的实现方式
// ================================
1. 使用模板特化
最直接的方式是使用模板特化：

// 通用算法模板
template<typename T>
T min(T a, T b) {
    return a < b ? a : b;
}

// 为字符串指针提供特化版本
template<>
const char* min<const char*>(const char* a, const char* b) {
    return strcmp(a, b) < 0 ? a : b;
}
这种方式的问题是，它只能特化完全匹配的类型，无法处理隐式转换或派生类型。

2. 使用函数重载
更灵活的方式是使用函数重载：

// 通用算法
template<typename T>
T min(T a, T b) {
    return a < b ? a : b;
}

// 为字符串指针提供重载版本
const char* min(const char* a, const char* b) {
    return strcmp(a, b) < 0 ? a : b;
}
函数重载允许编译器考虑隐式转换，提供更好的类型匹配。

3. 使用标签分发（Tag Dispatching）
标签分发是一种更强大的技术，它使用类型特征来选择适当的实现：

// 实现标签
struct generic_tag {};
struct optimized_tag {};

// 特征类，决定使用哪种实现
template<typename T>
struct min_trait {
    using category = generic_tag;
};

// 为字符串指针特化特征类
template<>
struct min_trait<const char*> {
    using category = optimized_tag;
};

// 实现函数
template<typename T>
T min_impl(T a, T b, generic_tag) {
    return a < b ? a : b;
}

const char* min_impl(const char* a, const char* b, optimized_tag) {
    return strcmp(a, b) < 0 ? a : b;
}

// 公共接口
template<typename T>
T min(T a, T b) {
    return min_impl(a, b, typename min_trait<T>::category());
}

标签分发允许我们基于类型特征选择实现，而不仅仅是基于类型本身。

4. 使用SFINAE（替换失败不是错误）
SFINAE允许我们基于类型特性选择重载：
// 通用实现
template<typename T>
typename std::enable_if<!std::is_pointer<T>::value, T>::type
min(T a, T b) {
    return a < b ? a : b;
}

// 指针类型的特殊实现
template<typename T>
typename std::enable_if<std::is_pointer<T>::value, T>::type
min(T a, T b) {
    return *a < *b ? a : b;
}

// 字符串指针的特殊实现
const char* min(const char* a, const char* b) {
    return strcmp(a, b) < 0 ? a : b;
}
SFINAE允许我们基于复杂的类型条件选择实现。

// ==================================
// 算法特化的实际应用
// ==================================
1. STL算法优化
标准库中的许多算法都使用特化来优化特定类型的操作：

// 通用的std::copy实现
template<typename InputIt, typename OutputIt>
OutputIt copy(InputIt first, InputIt last, OutputIt d_first) {
    while (first != last) {
        *d_first++ = *first++;
    }
    return d_first;
}

// 对于原始内存的优化实现
template<>
void* copy(const void* first, const void* last, void* d_first) {
    std::size_t size = static_cast<const char*>(last) - static_cast<const char*>(first);
    return std::memmove(d_first, first, size);
}

2. 数值计算优化
数值算法可以为特定类型提供高度优化的实现：

// 通用的平方根计算
template<typename T>
T sqrt(T x) {
    // 使用迭代算法...
}

// 对于float的优化实现
template<>
float sqrt<float>(float x) {
    // 使用硬件指令...
}

3. 容器操作优化
容器操作可以根据元素类型特性进行优化：

template<typename T>
void vector<T>::resize(size_type new_size) {
    if (new_size > size()) {
        // 根据T是否可平凡构造选择不同实现
        resize_impl(new_size, typename std::is_trivially_constructible<T>::type());
    }
}